home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 April: Mac OS SDK / Dev.CD Apr 99 SDK1.toast / Development Kits / Interfaces&Libraries / Universal / Interfaces / PInterfaces / DriverServices.p < prev    next >
Encoding:
Text File  |  1998-08-17  |  14.5 KB  |  461 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        DriverServices.p
  3.  
  4.      Contains:    Driver Services Interfaces.
  5.  
  6.      Version:    Technology:    PowerSurge 1.0.2
  7.                  Release:    Universal Interfaces 3.2
  8.  
  9.      Copyright:    © 1985-1998 by Apple Computer, Inc., all rights reserved
  10.  
  11.      Bugs?:        For bug reports, consult the following page on
  12.                  the World Wide Web:
  13.  
  14.                      http://developer.apple.com/bugreporter/
  15.  
  16. }
  17. {$IFC UNDEFINED UsingIncludes}
  18. {$SETC UsingIncludes := 0}
  19. {$ENDC}
  20.  
  21. {$IFC NOT UsingIncludes}
  22.  UNIT DriverServices;
  23.  INTERFACE
  24. {$ENDC}
  25.  
  26. {$IFC UNDEFINED __DRIVERSERVICES__}
  27. {$SETC __DRIVERSERVICES__ := 1}
  28.  
  29. {$I+}
  30. {$SETC DriverServicesIncludes := UsingIncludes}
  31. {$SETC UsingIncludes := 1}
  32.  
  33. {$IFC UNDEFINED __CONDITIONALMACROS__}
  34. {$I ConditionalMacros.p}
  35. {$ENDC}
  36. {$IFC UNDEFINED __MACTYPES__}
  37. {$I MacTypes.p}
  38. {$ENDC}
  39. {$IFC UNDEFINED __ERRORS__}
  40. {$I Errors.p}
  41. {$ENDC}
  42. {$IFC UNDEFINED __MACHINEEXCEPTIONS__}
  43. {$I MachineExceptions.p}
  44. {$ENDC}
  45. {$IFC UNDEFINED __DEVICES__}
  46. {$I Devices.p}
  47. {$ENDC}
  48. {$IFC UNDEFINED __DRIVERSYNCHRONIZATION__}
  49. {$I DriverSynchronization.p}
  50. {$ENDC}
  51.  
  52.  
  53. {$PUSH}
  54. {$ALIGN POWER}
  55. {$LibExport+}
  56.  
  57. {*****************************************************************
  58.  *
  59.  *         Previously in Kernel.h
  60.  *
  61.  *****************************************************************}
  62. {  Kernel basics }
  63.  
  64. TYPE
  65.     IOPreparationID = ^LONGINT;
  66.     SoftwareInterruptID = ^LONGINT;
  67.     TaskID = ^LONGINT;
  68.     TimerID = ^LONGINT;
  69. {  OrderedItem stuff }
  70.     OrderedItemService                    = OSType;
  71.     OrderedItemSignature                = OSType;
  72.  
  73. CONST
  74.     kMatchAnyOrderedItemService    = '****';
  75.     kMatchAnyOrderedItemSignature = '****';
  76.     kDoNotMatchAnyOrderedItemService = '----';
  77.     kDoNotMatchAnyOrderedItemSignature = '----';
  78.  
  79.  
  80. TYPE
  81.     OrderedItemNamePtr = ^OrderedItemName;
  82.     OrderedItemName = RECORD
  83.         service:                OrderedItemService;
  84.         signature:                OrderedItemSignature;
  85.     END;
  86.  
  87.     OrderedItemOptions                    = OptionBits;
  88.  
  89. CONST
  90.     kOrderedItemIsRightBefore    = $00000001;
  91.     kOrderedItemIsRightAfter    = $00000002;
  92.  
  93.  
  94. TYPE
  95.     OrderRequirementsPtr = ^OrderRequirements;
  96.     OrderRequirements = RECORD
  97.         options:                OrderedItemOptions;
  98.         itemBefore:                OrderedItemName;
  99.         itemAfter:                OrderedItemName;
  100.     END;
  101.  
  102. {  Tasking }
  103.     ExecutionLevel                        = UInt32;
  104.  
  105. CONST
  106.     kTaskLevel                    = 0;
  107.     kSoftwareInterruptLevel        = 1;
  108.     kAcceptFunctionLevel        = 2;
  109.     kKernelLevel                = 3;
  110.     kSIHAcceptFunctionLevel        = 4;
  111.     kSecondaryInterruptLevel    = 5;
  112.     kHardwareInterruptLevel        = 6;
  113.  
  114.  
  115. TYPE
  116. {$IFC TYPED_FUNCTION_POINTERS}
  117.     SoftwareInterruptHandler = PROCEDURE(p1: UNIV Ptr; p2: UNIV Ptr); C;
  118. {$ELSEC}
  119.     SoftwareInterruptHandler = ProcPtr;
  120. {$ENDC}
  121.  
  122. {$IFC TYPED_FUNCTION_POINTERS}
  123.     SecondaryInterruptHandler2 = FUNCTION(p1: UNIV Ptr; p2: UNIV Ptr): OSStatus; C;
  124. {$ELSEC}
  125.     SecondaryInterruptHandler2 = ProcPtr;
  126. {$ENDC}
  127.  
  128.  
  129. CONST
  130.     kCurrentAddressSpaceID        = -1;
  131.  
  132.  
  133. {  Memory System basics }
  134.  
  135. TYPE
  136.     LogicalAddressRangePtr = ^LogicalAddressRange;
  137.     LogicalAddressRange = RECORD
  138.         address:                LogicalAddress;
  139.         count:                    ByteCount;
  140.     END;
  141.  
  142.     PhysicalAddressRangePtr = ^PhysicalAddressRange;
  143.     PhysicalAddressRange = RECORD
  144.         address:                PhysicalAddress;
  145.         count:                    ByteCount;
  146.     END;
  147.  
  148. {  For PrepareMemoryForIO and CheckpointIO }
  149.     IOPreparationOptions                = OptionBits;
  150.  
  151. CONST
  152.     kIOMultipleRanges            = $00000001;
  153.     kIOLogicalRanges            = $00000002;
  154.     kIOMinimalLogicalMapping    = $00000004;
  155.     kIOShareMappingTables        = $00000008;
  156.     kIOIsInput                    = $00000010;
  157.     kIOIsOutput                    = $00000020;
  158.     kIOCoherentDataPath            = $00000040;
  159.     kIOTransferIsLogical        = $00000080;
  160.     kIOClientIsUserMode            = $00000080;
  161.  
  162.  
  163. TYPE
  164.     IOPreparationState                    = OptionBits;
  165.  
  166. CONST
  167.     kIOStateDone                = $00000001;
  168.  
  169.     kInvalidPageAddress            = -1;
  170.  
  171.  
  172. TYPE
  173.     AddressRangePtr = ^AddressRange;
  174.     AddressRange = RECORD
  175.         base:                    Ptr;
  176.         length:                    ByteCount;
  177.     END;
  178.  
  179. {  C's treatment of arrays and array pointers is atypical }
  180.     LogicalMappingTable                    = ARRAY [0..0] OF LogicalAddress;
  181.     LogicalMappingTablePtr                = ^LogicalMappingTable;
  182.     PhysicalMappingTable                = ARRAY [0..0] OF PhysicalAddress;
  183.     PhysicalMappingTablePtr                = ^PhysicalMappingTable;
  184.     AddressRangeTable                    = ARRAY [0..0] OF AddressRange;
  185.     AddressRangeTablePtr                = ^AddressRangeTable;
  186.     MultipleAddressRangePtr = ^MultipleAddressRange;
  187.     MultipleAddressRange = RECORD
  188.         entryCount:                ItemCount;
  189.         rangeTable:                AddressRangeTablePtr;
  190.     END;
  191.  
  192. {
  193.    Separate C definition so that union has a name.  A future version of the interfacer
  194.    tool will allow a name (that gets thrown out in Pascal and Asm).
  195. }
  196.     IOPreparationTablePtr = ^IOPreparationTable;
  197.     IOPreparationTable = RECORD
  198.         options:                IOPreparationOptions;
  199.         state:                    IOPreparationState;
  200.         preparationID:            IOPreparationID;
  201.         addressSpace:            AddressSpaceID;
  202.         granularity:            ByteCount;
  203.         firstPrepared:            ByteCount;
  204.         lengthPrepared:            ByteCount;
  205.         mappingEntryCount:        ItemCount;
  206.         logicalMapping:            LogicalMappingTablePtr;
  207.         physicalMapping:        PhysicalMappingTablePtr;
  208.         CASE INTEGER OF
  209.         0: (
  210.             range:                AddressRange;
  211.             );
  212.         1: (
  213.             multipleRanges:        MultipleAddressRange;
  214.             );
  215.     END;
  216.  
  217.     IOCheckpointOptions                    = OptionBits;
  218.  
  219. CONST
  220.     kNextIOIsInput                = $00000001;
  221.     kNextIOIsOutput                = $00000002;
  222.     kMoreIOTransfers            = $00000004;
  223.  
  224. {  For SetProcessorCacheMode }
  225.  
  226.  
  227. TYPE
  228.     ProcessorCacheMode                    = UInt32;
  229.  
  230. CONST
  231.     kProcessorCacheModeDefault    = 0;
  232.     kProcessorCacheModeInhibited = 1;
  233.     kProcessorCacheModeWriteThrough = 2;
  234.     kProcessorCacheModeCopyBack    = 3;
  235.  
  236. {
  237.    For GetPageInformation
  238.    (Note: if kPageInformationVersion fails, try 0 -- old versions of DSL defined  kPageInformationVersion as 0)
  239. }
  240.  
  241.     kPageInformationVersion        = 1;
  242.  
  243.  
  244. TYPE
  245.     PageStateInformation                = UInt32;
  246.  
  247. CONST
  248.     kPageIsProtected            = $00000001;
  249.     kPageIsProtectedPrivileged    = $00000002;
  250.     kPageIsModified                = $00000004;
  251.     kPageIsReferenced            = $00000008;
  252.     kPageIsLockedResident        = $00000010;                    {  held and locked resident }
  253.     kPageIsInMemory                = $00000020;
  254.     kPageIsShared                = $00000040;
  255.     kPageIsWriteThroughCached    = $00000080;
  256.     kPageIsCopyBackCached        = $00000100;
  257.     kPageIsHeldResident            = $00000200;                    {  held resident - use kPageIsLockedResident to check for locked state }
  258.     kPageIsLocked                = $00000010;                    {  Deprecated }
  259.     kPageIsResident                = $00000020;                    {  Deprecated }
  260.  
  261.  
  262. TYPE
  263.     PageInformationPtr = ^PageInformation;
  264.     PageInformation = RECORD
  265.         area:                    AreaID;
  266.         count:                    ItemCount;
  267.         information:            ARRAY [0..0] OF PageStateInformation;
  268.     END;
  269.  
  270.  
  271. {  Tasks  }
  272. FUNCTION CurrentExecutionLevel: ExecutionLevel; C;
  273. FUNCTION CurrentTaskID: TaskID; C;
  274. FUNCTION DelayFor(delayDuration: Duration): OSStatus; C;
  275. FUNCTION InPrivilegedMode: BOOLEAN; C;
  276.  
  277. {  Software Interrupts  }
  278. FUNCTION CreateSoftwareInterrupt(handler: SoftwareInterruptHandler; task: TaskID; p1: UNIV Ptr; persistent: BOOLEAN; VAR theSoftwareInterrupt: SoftwareInterruptID): OSStatus; C;
  279.  
  280. FUNCTION SendSoftwareInterrupt(theSoftwareInterrupt: SoftwareInterruptID; p2: UNIV Ptr): OSStatus; C;
  281. FUNCTION DeleteSoftwareInterrupt(theSoftwareInterrupt: SoftwareInterruptID): OSStatus; C;
  282. {$IFC TARGET_OS_MAC }
  283. {  Secondary Interrupts  }
  284. FUNCTION CallSecondaryInterruptHandler2(theHandler: SecondaryInterruptHandler2; exceptionHandler: ExceptionHandler; p1: UNIV Ptr; p2: UNIV Ptr): OSStatus; C;
  285. FUNCTION QueueSecondaryInterruptHandler(theHandler: SecondaryInterruptHandler2; exceptionHandler: ExceptionHandler; p1: UNIV Ptr; p2: UNIV Ptr): OSStatus; C;
  286. {$ENDC}  {TARGET_OS_MAC}
  287.  
  288. {  Timers  }
  289. FUNCTION SetInterruptTimer({CONST}VAR expirationTime: AbsoluteTime; handler: SecondaryInterruptHandler2; p1: UNIV Ptr; VAR theTimer: TimerID): OSStatus; C;
  290. FUNCTION CancelTimer(theTimer: TimerID; VAR timeRemaining: AbsoluteTime): OSStatus; C;
  291.  
  292. {  I/O related Operations  }
  293. FUNCTION PrepareMemoryForIO(VAR theIOPreparationTable: IOPreparationTable): OSStatus; C;
  294. FUNCTION CheckpointIO(theIOPreparation: IOPreparationID; options: IOCheckpointOptions): OSStatus; C;
  295.  
  296. {  Memory Operations  }
  297. FUNCTION GetPageInformation(addressSpace: AddressSpaceID; base: ConstLogicalAddress; length: ByteCount; version: PBVersion; VAR thePageInfo: PageInformation): OSStatus; C;
  298. {  Processor Cache Related  }
  299. FUNCTION SetProcessorCacheMode(addressSpace: AddressSpaceID; base: ConstLogicalAddress; length: ByteCount; cacheMode: ProcessorCacheMode): OSStatus; C;
  300. {*****************************************************************
  301.  *
  302.  *         Was in DriverSupport.h or DriverServices.h
  303.  *
  304.  *****************************************************************}
  305.  
  306. TYPE
  307.     DeviceLogicalAddressPtr                = ^LogicalAddress;
  308.  
  309. CONST
  310.     durationMicrosecond            = -1;                            {  Microseconds are negative }
  311.     durationMillisecond            = 1;                            {  Milliseconds are positive }
  312.     durationSecond                = 1000;                            {  1000 * durationMillisecond }
  313.     durationMinute                = 60000;                        {  60 * durationSecond, }
  314.     durationHour                = 3600000;                        {  60 * durationMinute, }
  315.     durationDay                    = 86400000;                        {  24 * durationHour, }
  316.     durationNoWait                = 0;                            {  don't block }
  317.     durationForever                = $7FFFFFFF;                    {  no time limit }
  318.  
  319.     k8BitAccess                    = 0;                            {  access as 8 bit }
  320.     k16BitAccess                = 1;                            {  access as 16 bit }
  321.     k32BitAccess                = 2;                            {  access as 32 bit }
  322.  
  323.  
  324. TYPE
  325.     Nanoseconds                            = UnsignedWide;
  326.     NanosecondsPtr                         = ^Nanoseconds;
  327.  
  328. FUNCTION IOCommandIsComplete(theID: IOCommandID; theResult: OSErr): OSErr; C;
  329. FUNCTION GetIOCommandInfo(theID: IOCommandID; VAR theContents: IOCommandContents; VAR theCommand: IOCommandCode; VAR theKind: IOCommandKind): OSErr; C;
  330. PROCEDURE UpdateDeviceActivity(VAR deviceEntry: RegEntryID); C;
  331. PROCEDURE BlockCopy(srcPtr: UNIV Ptr; destPtr: UNIV Ptr; byteCount: Size); C;
  332. FUNCTION PoolAllocateResident(byteSize: ByteCount; clear: BOOLEAN): LogicalAddress; C;
  333. FUNCTION PoolDeallocate(address: LogicalAddress): OSStatus; C;
  334. FUNCTION GetLogicalPageSize: ByteCount; C;
  335. FUNCTION GetDataCacheLineSize: ByteCount; C;
  336. FUNCTION FlushProcessorCache(spaceID: AddressSpaceID; base: LogicalAddress; length: ByteCount): OSStatus; C;
  337. FUNCTION MemAllocatePhysicallyContiguous(byteSize: ByteCount; clear: BOOLEAN): LogicalAddress; C;
  338. FUNCTION MemDeallocatePhysicallyContiguous(address: LogicalAddress): OSStatus; C;
  339.  
  340. FUNCTION UpTime: AbsoluteTime; C;
  341. PROCEDURE GetTimeBaseInfo(VAR minAbsoluteTimeDelta: UInt32; VAR theAbsoluteTimeToNanosecondNumerator: UInt32; VAR theAbsoluteTimeToNanosecondDenominator: UInt32; VAR theProcessorToAbsoluteTimeNumerator: UInt32; VAR theProcessorToAbsoluteTimeDenominator: UInt32); C;
  342.  
  343. FUNCTION AbsoluteToNanoseconds(absoluteTime: AbsoluteTime): Nanoseconds; C;
  344. FUNCTION AbsoluteToDuration(absoluteTime: AbsoluteTime): Duration; C;
  345. FUNCTION NanosecondsToAbsolute(nanoseconds: Nanoseconds): AbsoluteTime; C;
  346. FUNCTION DurationToAbsolute(duration: Duration): AbsoluteTime; C;
  347. FUNCTION AddAbsoluteToAbsolute(absoluteTime1: AbsoluteTime; absoluteTime2: AbsoluteTime): AbsoluteTime; C;
  348. FUNCTION SubAbsoluteFromAbsolute(leftAbsoluteTime: AbsoluteTime; rightAbsoluteTime: AbsoluteTime): AbsoluteTime; C;
  349. FUNCTION AddNanosecondsToAbsolute(nanoseconds: Nanoseconds; absoluteTime: AbsoluteTime): AbsoluteTime; C;
  350. FUNCTION AddDurationToAbsolute(duration: Duration; absoluteTime: AbsoluteTime): AbsoluteTime; C;
  351. FUNCTION SubNanosecondsFromAbsolute(nanoseconds: Nanoseconds; absoluteTime: AbsoluteTime): AbsoluteTime; C;
  352. FUNCTION SubDurationFromAbsolute(duration: Duration; absoluteTime: AbsoluteTime): AbsoluteTime; C;
  353. FUNCTION AbsoluteDeltaToNanoseconds(leftAbsoluteTime: AbsoluteTime; rightAbsoluteTime: AbsoluteTime): Nanoseconds; C;
  354. FUNCTION AbsoluteDeltaToDuration(leftAbsoluteTime: AbsoluteTime; rightAbsoluteTime: AbsoluteTime): Duration; C;
  355. FUNCTION DurationToNanoseconds(theDuration: Duration): Nanoseconds; C;
  356. FUNCTION NanosecondsToDuration(theNanoseconds: Nanoseconds): Duration; C;
  357.  
  358. FUNCTION PBQueueInit(qHeader: QHdrPtr): OSErr; C;
  359. FUNCTION PBQueueCreate(VAR qHeader: QHdrPtr): OSErr; C;
  360. FUNCTION PBQueueDelete(qHeader: QHdrPtr): OSErr; C;
  361. PROCEDURE PBEnqueue(qElement: QElemPtr; qHeader: QHdrPtr); C;
  362. FUNCTION PBEnqueueLast(qElement: QElemPtr; qHeader: QHdrPtr): OSErr; C;
  363. FUNCTION PBDequeue(qElement: QElemPtr; qHeader: QHdrPtr): OSErr; C;
  364. FUNCTION PBDequeueFirst(qHeader: QHdrPtr; VAR theFirstqElem: QElemPtr): OSErr; C;
  365. FUNCTION PBDequeueLast(qHeader: QHdrPtr; VAR theLastqElem: QElemPtr): OSErr; C;
  366. FUNCTION DeviceProbe(theSrc: UNIV Ptr; theDest: UNIV Ptr; AccessType: UInt32): OSStatus; C;
  367. FUNCTION DelayForHardware(absoluteTime: AbsoluteTime): OSStatus; C;
  368.  
  369.  
  370. {*****************************************************************
  371.  *
  372.  *         Was in Interrupts.h 
  373.  *
  374.  *****************************************************************}
  375. {  Interrupt types  }
  376.  
  377. TYPE
  378.     InterruptSetID = ^LONGINT;
  379.     InterruptMemberNumber                = LONGINT;
  380.     InterruptSetMemberPtr = ^InterruptSetMember;
  381.     InterruptSetMember = RECORD
  382.         setID:                    InterruptSetID;
  383.         member:                    InterruptMemberNumber;
  384.     END;
  385.  
  386.  
  387. CONST
  388.     kISTChipInterruptSource        = 0;
  389.     kISTOutputDMAInterruptSource = 1;
  390.     kISTInputDMAInterruptSource    = 2;
  391.     kISTPropertyMemberCount        = 3;
  392.  
  393.  
  394. TYPE
  395.     ISTProperty                            = ARRAY [0..2] OF InterruptSetMember;
  396.     InterruptReturnValue                = LONGINT;
  397.  
  398. CONST
  399.     kFirstMemberNumber            = 1;
  400.     kIsrIsComplete                = 0;
  401.     kIsrIsNotComplete            = -1;
  402.     kMemberNumberParent            = -2;
  403.  
  404.  
  405. TYPE
  406.     InterruptSourceState                = BOOLEAN;
  407.  
  408. CONST
  409.     kSourceWasEnabled            = true;
  410.     kSourceWasDisabled            = false;
  411.  
  412.  
  413.  
  414. TYPE
  415. {$IFC TYPED_FUNCTION_POINTERS}
  416.     InterruptHandler = FUNCTION(ISTmember: InterruptSetMember; refCon: UNIV Ptr; theIntCount: UInt32): InterruptMemberNumber; C;
  417. {$ELSEC}
  418.     InterruptHandler = ProcPtr;
  419. {$ENDC}
  420.  
  421. {$IFC TYPED_FUNCTION_POINTERS}
  422.     InterruptEnabler = PROCEDURE(ISTmember: InterruptSetMember; refCon: UNIV Ptr); C;
  423. {$ELSEC}
  424.     InterruptEnabler = ProcPtr;
  425. {$ENDC}
  426.  
  427. {$IFC TYPED_FUNCTION_POINTERS}
  428.     InterruptDisabler = FUNCTION(ISTmember: InterruptSetMember; refCon: UNIV Ptr): ByteParameter; C;
  429. {$ELSEC}
  430.     InterruptDisabler = ProcPtr;
  431. {$ENDC}
  432.  
  433.  
  434. CONST
  435.     kReturnToParentWhenComplete    = $00000001;
  436.     kReturnToParentWhenNotComplete = $00000002;
  437.  
  438.  
  439. TYPE
  440.     InterruptSetOptions                    = OptionBits;
  441. {  Interrupt Services  }
  442. FUNCTION CreateInterruptSet(parentSet: InterruptSetID; parentMember: InterruptMemberNumber; setSize: InterruptMemberNumber; VAR setID: InterruptSetID; options: InterruptSetOptions): OSStatus; C;
  443.  
  444. FUNCTION InstallInterruptFunctions(setID: InterruptSetID; member: InterruptMemberNumber; refCon: UNIV Ptr; handlerFunction: InterruptHandler; enableFunction: InterruptEnabler; disableFunction: InterruptDisabler): OSStatus; C;
  445.  
  446. FUNCTION GetInterruptFunctions(setID: InterruptSetID; member: InterruptMemberNumber; VAR refCon: UNIV Ptr; VAR handlerFunction: InterruptHandler; VAR enableFunction: InterruptEnabler; VAR disableFunction: InterruptDisabler): OSStatus; C;
  447. FUNCTION ChangeInterruptSetOptions(setID: InterruptSetID; options: InterruptSetOptions): OSStatus; C;
  448. FUNCTION GetInterruptSetOptions(setID: InterruptSetID; VAR options: InterruptSetOptions): OSStatus; C;
  449.  
  450.  
  451. {$ALIGN RESET}
  452. {$POP}
  453.  
  454. {$SETC UsingIncludes := DriverServicesIncludes}
  455.  
  456. {$ENDC} {__DRIVERSERVICES__}
  457.  
  458. {$IFC NOT UsingIncludes}
  459.  END.
  460. {$ENDC}
  461.